package com.project.sianet.util.pushnotifications;

import java.io.IOException;
import java.util.concurrent.atomic.AtomicInteger;

import android.content.SharedPreferences;

import com.google.android.gms.gcm.GoogleCloudMessaging;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.AsyncTask;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.util.Log;

//
//import static com.project.sianet.util.pushnotifications.CommonUtilities.SERVER_URL;
//import static com.project.sianet.util.pushnotifications.CommonUtilities.TAG;
//import static com.project.sianet.util.pushnotifications.CommonUtilities.displayMessage;
//
//import java.io.IOException;
//import java.io.OutputStream;
//import java.net.HttpURLConnection;
//import java.net.MalformedURLException;
//import java.net.URL;
//import java.util.HashMap;
//import java.util.Iterator;
//import java.util.Map;
//import java.util.Map.Entry;
//import java.util.Random;
// 
//
//import android.content.Context;
//import android.util.Log;
// 
//
//import com.google.android.gcm.GCMRegistrar;
//import com.project.sianet.R;
//
public final class ServerUtilities {

	/**
     * Send an upstream GCM message to the 3rd party server to remove this 
     * device's registration ID, and contact the GCM server to do the same.
     */
	public static void unregister(final Context context, final String regid) {
	
		final GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(context);
		final AtomicInteger msgId = new AtomicInteger();
		
		Log.d(CommonUtilities.TAG, "UNREGISTER USERID: " + regid);
		new AsyncTask<Void, Void, String>()
		{
		    @Override
		    protected String doInBackground(Void... params)
		    {
			String msg = "";
			try
			{
			    Bundle data = new Bundle();
			    data.putString("action", "com.project.sianet.util.pushnotifications.UNREGISTER");
			    String id = Integer.toString(msgId.incrementAndGet());
			    gcm.send(CommonUtilities.GCM_SENDER_ID + "@gcm.googleapis.com", id, CommonUtilities.GCM_TIME_TO_LIVE, data);
			    msg = "Sent unregistration";
			    gcm.unregister();
			}
			catch (IOException ex)
			{
			    msg = "Error :" + ex.getMessage();
			}
			return msg;
		    }
	
		    @Override
		    protected void onPostExecute(String msg) {
		    	removeRegistrationId(context, regid);
		    }
		}.execute();
	
	}
	
	/**
     * Removes the registration ID from the application's 
     * {@code SharedPreferences}.
     * @param context 
     * 		the application context
     */
    private static void removeRegistrationId(Context context, String regid) {
		final SharedPreferences prefs = getGcmPreferences(context);
		int appVersion = getAppVersion(context);
		Log.i(CommonUtilities.TAG, "Removig regId on app version " + appVersion);
		SharedPreferences.Editor editor = prefs.edit();
		editor.remove(CommonUtilities.PREFS_PROPERTY_REG_ID);
		editor.commit();
		regid = null;
    }
    
    /**
     * @return Application's {@code SharedPreferences}.
     */
    private static SharedPreferences getGcmPreferences(Context context) {
		// This sample app persists the registration ID in shared preferences,
		// but how you store the regID in your app is up to you.
//		return context.getSharedPreferences(CommonUtilities.PREFS_NAME, Context.MODE_PRIVATE);
		return PreferenceManager.getDefaultSharedPreferences(context);
    }
    
    /**
     * @return Application's version code from the {@code PackageManager}.
     */
    private static int getAppVersion(Context context) {
		try
		{
		    PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
		    return packageInfo.versionCode;
		}
		catch (NameNotFoundException e)
		{
		    // should never happen
		    throw new RuntimeException("Could not get package name: " + e);
		}
    }

//
//	private static final int MAX_ATTEMPTS = 5;
//    private static final int BACKOFF_MILLI_SECONDS = 2000;
//    private static final Random random = new Random();
// 
//    /**
//     * Register this account/device pair within the server.
//     *
//     */
//    public static void register(final Context context, String name, String email, final String regId) {
//        Log.i(TAG, "registering device (regId = " + regId + ")");
//        String serverUrl = SERVER_URL;
//        Map<String, String> params = new HashMap<String, String>();
//        params.put("regId", regId);
//        params.put("name", name);
//        params.put("email", email);
//         
//        long backoff = BACKOFF_MILLI_SECONDS + random.nextInt(1000);
//        // Once GCM returns a registration id, we need to register on our server
//        // As the server might be down, we will retry it a couple
//        // times.
//        for (int i = 1; i <= MAX_ATTEMPTS; i++) {
//            Log.d(TAG, "Attempt #" + i + " to register");
//            try {
//                displayMessage(context, context.getString(
//                        R.string.server_registering, i, MAX_ATTEMPTS));
//                post(serverUrl, params);
//                GCMRegistrar.setRegisteredOnServer(context, true);
//                String message = context.getString(R.string.server_registered);
//                CommonUtilities.displayMessage(context, message);
//                return;
//            } catch (IOException e) {
//                // Here we are simplifying and retrying on any error; in a real
//                // application, it should retry only on unrecoverable errors
//                // (like HTTP error code 503).
//                Log.e(TAG, "Failed to register on attempt " + i + ":" + e);
//                if (i == MAX_ATTEMPTS) {
//                    break;
//                }
//                try {
//                    Log.d(TAG, "Sleeping for " + backoff + " ms before retry");
//                    Thread.sleep(backoff);
//                } catch (InterruptedException e1) {
//                    // Activity finished before we complete - exit.
//                    Log.d(TAG, "Thread interrupted: abort remaining retries!");
//                    Thread.currentThread().interrupt();
//                    return;
//                }
//                // increase backoff exponentially
//                backoff *= 2;
//            }
//        }
//        String message = context.getString(R.string.server_register_error,
//                MAX_ATTEMPTS);
//        CommonUtilities.displayMessage(context, message);
//    }
// 
//    /**
//     * Unregister this account/device pair within the server.
//     */
//    public static void unregister(final Context context, final String regId) {
//        Log.i(TAG, "unregistering device (regId = " + regId + ")");
//        String serverUrl = SERVER_URL + "/unregister";
//        Map<String, String> params = new HashMap<String, String>();
//        params.put("regId", regId);
//        try {
//            post(serverUrl, params);
//            GCMRegistrar.setRegisteredOnServer(context, false);
//            String message = context.getString(R.string.server_unregistered);
//            CommonUtilities.displayMessage(context, message);
//        } catch (IOException e) {
//            // At this point the device is unregistered from GCM, but still
//            // registered in the server.
//            // We could try to unregister again, but it is not necessary:
//            // if the server tries to send a message to the device, it will get
//            // a "NotRegistered" error message and should unregister the device.
//            String message = context.getString(R.string.server_unregister_error,
//                    e.getMessage());
//            CommonUtilities.displayMessage(context, message);
//        }
//    }
// 
//    /**
//     * Issue a POST request to the server.
//     *
//     * @param endpoint POST address.
//     * @param params request parameters.
//     *
//     * @throws IOException propagated from POST.
//     */
//    private static void post(String endpoint, Map<String, String> params)
//            throws IOException {    
//         
//        URL url;
//        try {
//            url = new URL(endpoint);
//        } catch (MalformedURLException e) {
//            throw new IllegalArgumentException("invalid url: " + endpoint);
//        }
//        StringBuilder bodyBuilder = new StringBuilder();
//        Iterator<Entry<String, String>> iterator = params.entrySet().iterator();
//        // constructs the POST body using the parameters
//        while (iterator.hasNext()) {
//            Entry<String, String> param = iterator.next();
//            bodyBuilder.append(param.getKey()).append('=')
//                    .append(param.getValue());
//            if (iterator.hasNext()) {
//                bodyBuilder.append('&');
//            }
//        }
//        String body = bodyBuilder.toString();
//        Log.v(TAG, "Posting '" + body + "' to " + url);
//        byte[] bytes = body.getBytes();
//        HttpURLConnection conn = null;
//        try {
//            Log.e("URL", "> " + url);
//            conn = (HttpURLConnection) url.openConnection();
//            conn.setDoOutput(true);
//            conn.setUseCaches(false);
//            conn.setFixedLengthStreamingMode(bytes.length);
//            conn.setRequestMethod("POST");
//            conn.setRequestProperty("Content-Type",
//                    "application/x-www-form-urlencoded;charset=UTF-8");
//            // post the request
//            OutputStream out = conn.getOutputStream();
//            out.write(bytes);
//            out.close();
//            // handle the response
//            int status = conn.getResponseCode();
//            if (status != 200) {
//              throw new IOException("Post failed with error code " + status);
//            }
//        } finally {
//            if (conn != null) {
//                conn.disconnect();
//            }
//        }
//      }
//	
}
